home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / amiga / uae-0.7.0b2 / src / newcpu.c < prev    next >
C/C++ Source or Header  |  1998-01-20  |  33KB  |  1,283 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   *
  4.   * MC68000 emulation
  5.   *
  6.   * (c) 1995 Bernd Schmidt
  7.   */
  8.  
  9. #include "sysconfig.h"
  10. #include "sysdeps.h"
  11.  
  12. #include "config.h"
  13. #include "options.h"
  14. #include "gensound.h"
  15. #include "sounddep/sound.h"
  16. #include "events.h"
  17. #include "uae.h"
  18. #include "machdep/m68k.h"
  19. #include "memory.h"
  20. #include "custom.h"
  21. #include "readcpu.h"
  22. #include "newcpu.h"
  23. #include "autoconf.h"
  24. #include "ersatz.h"
  25. #include "debug.h"
  26. #include "compiler.h"
  27.  
  28. /* Opcode of faulting instruction */
  29. uae_u16 last_op_for_exception_3;
  30. /* PC at fault time */
  31. uaecptr last_addr_for_exception_3;
  32. /* Address that generated the exception */
  33. uaecptr last_fault_for_exception_3;
  34.  
  35. int areg_byteinc[] = { 1,1,1,1,1,1,1,2 };
  36. int imm8_table[] = { 8,1,2,3,4,5,6,7 };
  37.  
  38. int movem_index1[256];
  39. int movem_index2[256];
  40. int movem_next[256];
  41.  
  42. int fpp_movem_index1[256];
  43. int fpp_movem_index2[256];
  44. int fpp_movem_next[256];
  45.  
  46. cpuop_func *cpufunctbl[65536];
  47.  
  48. #define COUNT_INSTRS 0
  49.  
  50. #if COUNT_INSTRS
  51. static unsigned long int instrcount[65536];
  52. static uae_u16 opcodenums[65536];
  53.  
  54. static int compfn(const void *el1, const void *el2)
  55. {
  56.     return instrcount[*(const uae_u16 *)el1] < instrcount[*(const uae_u16 *)el2];
  57. }
  58.  
  59. static char *icountfilename (void)
  60. {
  61.     char *name = getenv ("INSNCOUNT");
  62.     if (name)
  63.     return name;
  64.     return COUNT_INSTRS == 2 ? "frequent.68k" : "insncount";
  65. }
  66.  
  67. void dump_counts(void)
  68. {
  69.     FILE *f = fopen(icountfilename(), "w");
  70.     unsigned long int total;
  71.     int i;
  72.  
  73.     write_log ("Writing instruction count file...\n");
  74.     for(i=0; i < 65536; i++) {
  75.     opcodenums[i] = i;
  76.     total += instrcount[i];
  77.     }
  78.     qsort(opcodenums, 65536, sizeof(uae_u16), compfn);
  79.  
  80.     fprintf(f, "Total: %lu\n", total);
  81.     for(i=0; i < 65536; i++) {
  82.     unsigned long int cnt = instrcount[opcodenums[i]];
  83.     struct instr *dp;
  84.     struct mnemolookup *lookup;
  85.     if (!cnt)
  86.         break;
  87.     dp = table68k + opcodenums[i];
  88.     for (lookup = lookuptab;lookup->mnemo != dp->mnemo; lookup++) ;
  89.     fprintf(f, "%04x: %lu %s\n", opcodenums[i], cnt, lookup->name);
  90.     }
  91.     fclose(f);
  92. }
  93. #else
  94. void dump_counts(void)
  95. {
  96. }
  97. #endif
  98.  
  99. int broken_in;
  100.  
  101. void init_m68k (void)
  102. {
  103.     long int opcode;
  104.     int i,j;
  105.  
  106.     for (i = 0 ; i < 256 ; i++) {
  107.     for (j = 0 ; j < 8 ; j++) {
  108.         if (i & (1 << j)) break;
  109.     }
  110.     movem_index1[i] = j;
  111.     movem_index2[i] = 7-j;
  112.     movem_next[i] = i & (~(1 << j));
  113.     }
  114.     for (i = 0 ; i < 256 ; i++) {
  115.     for (j = 7 ; j >= 0 ; j--) {
  116.         if (i & (1 << j)) break;
  117.     }
  118.     fpp_movem_index1[i] = j;
  119.     fpp_movem_index2[i] = 7-j;
  120.     fpp_movem_next[i] = i & (~(1 << j));
  121.     }
  122. #if COUNT_INSTRS
  123.     {
  124.     FILE *f = fopen(icountfilename(), "r");
  125.     memset(instrcount, 0, sizeof instrcount);
  126.     if (f) {
  127.         uae_u32 opcode, count, total;
  128.         char name[20];
  129.         write_log ("Reading instruction count file...\n");
  130.         fscanf(f,"Total: %lu\n",&total);
  131.         while(fscanf(f,"%lx: %lu %s\n",&opcode,&count,name)==3) {
  132.         instrcount[opcode] = count;
  133.         }
  134.         fclose(f);
  135.     }
  136.     }
  137. #endif
  138.     write_log("Building CPU table... ");
  139.     read_table68k ();
  140.     do_merges ();
  141.  
  142.     sprintf(warning_buffer, "%d CPU functions\n", nr_cpuop_funcs);
  143.     write_log (warning_buffer);
  144.  
  145.     for (opcode = 0; opcode < 65536; opcode++)
  146.     cpufunctbl[opcode] = op_illg;
  147.     for (i = 0; op_smalltbl[i].handler != NULL; i++) {
  148.     if (!op_smalltbl[i].specific)
  149.         cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
  150.     }
  151.     for (opcode = 0; opcode < 65536; opcode++) {
  152.     cpuop_func *f;
  153.  
  154.     if (table68k[opcode].mnemo == i_ILLG)
  155.         continue;
  156.  
  157.     if (table68k[opcode].handler != -1) {
  158.         f = cpufunctbl[table68k[opcode].handler];
  159.         if (f == op_illg)
  160.         abort();
  161.         cpufunctbl[opcode] = f;
  162.     }
  163.     }
  164.     for (i = 0; op_smalltbl[i].handler != NULL; i++) {
  165.     if (op_smalltbl[i].specific)
  166.         cpufunctbl[op_smalltbl[i].opcode] = op_smalltbl[i].handler;
  167.     }
  168. }
  169.  
  170. struct regstruct regs, lastint_regs;
  171. static struct regstruct regs_backup[16];
  172. static int backup_pointer = 0;
  173. static long int m68kpc_offset;
  174. int lastint_no;
  175.  
  176. uae_s32 ShowEA(int reg, amodes mode, wordsizes size, char *buf)
  177. {
  178.     uae_u16 dp;
  179.     uae_s8 disp8;
  180.     uae_s16 disp16;
  181.     int r;
  182.     uae_u32 dispreg;
  183.     uaecptr addr;
  184.     uae_s32 offset = 0;
  185.     char buffer[80];
  186.  
  187.     switch(mode){
  188.      case Dreg:
  189.     sprintf(buffer,"D%d", reg);
  190.     break;
  191.      case Areg:
  192.     sprintf(buffer,"A%d", reg);
  193.     break;
  194.      case Aind:
  195.     sprintf(buffer,"(A%d)", reg);
  196.     break;
  197.      case Aipi:
  198.     sprintf(buffer,"(A%d)+", reg);
  199.     break;
  200.      case Apdi:
  201.     sprintf(buffer,"-(A%d)", reg);
  202.     break;
  203.      case Ad16:
  204.     disp16 = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  205.     addr = m68k_areg(regs,reg) + (uae_s16)disp16;
  206.     sprintf(buffer,"(A%d,$%04x) == $%08lx", reg, disp16 & 0xffff,
  207.                     (long unsigned int)addr);
  208.     break;
  209.      case Ad8r:
  210.     dp = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  211.     disp8 = dp & 0xFF;
  212.     r = (dp & 0x7000) >> 12;
  213.     dispreg = dp & 0x8000 ? m68k_areg(regs,r) : m68k_dreg(regs,r);
  214.     if (!(dp & 0x800)) dispreg = (uae_s32)(uae_s16)(dispreg);
  215.     dispreg <<= (dp >> 9) & 3;
  216.  
  217.     if (dp & 0x100) {
  218.         uae_s32 outer = 0, disp = 0;
  219.         uae_s32 base = m68k_areg(regs,reg);
  220.         char name[10];
  221.         sprintf(name,"A%d, ",reg);
  222.         if (dp & 0x80) { base = 0; name[0] = 0; }
  223.         if (dp & 0x40) dispreg = 0;
  224.         if ((dp & 0x30) == 0x20) { disp = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  225.         if ((dp & 0x30) == 0x30) { disp = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  226.         base += disp;
  227.  
  228.         if ((dp & 0x3) == 0x2) { outer = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  229.         if ((dp & 0x3) == 0x3) { outer = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  230.  
  231.         if (!(dp & 4)) base += dispreg;
  232.         if (dp & 3) base = get_long (base);
  233.         if (dp & 4) base += dispreg;
  234.  
  235.         addr = base + outer;
  236.         sprintf(buffer,"(%s%c%d.%c*%d+%ld)+%ld == $%08lx", name,
  237.             dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  238.             1 << ((dp >> 9) & 3),
  239.             disp,outer,
  240.             (long unsigned int)addr);
  241.     } else {
  242.       addr = m68k_areg(regs,reg) + (uae_s32)((uae_s8)disp8) + dispreg;
  243.       sprintf(buffer,"(A%d, %c%d.%c*%d, $%02x) == $%08lx", reg,
  244.            dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  245.            1 << ((dp >> 9) & 3), disp8,
  246.            (long unsigned int)addr);
  247.     }
  248.     break;
  249.      case PC16:
  250.     addr = m68k_getpc() + m68kpc_offset;
  251.     disp16 = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  252.     addr += (uae_s16)disp16;
  253.     sprintf(buffer,"(PC,$%04x) == $%08lx", disp16 & 0xffff,(long unsigned int)addr);
  254.     break;
  255.      case PC8r:
  256.     addr = m68k_getpc() + m68kpc_offset;
  257.     dp = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  258.     disp8 = dp & 0xFF;
  259.     r = (dp & 0x7000) >> 12;
  260.     dispreg = dp & 0x8000 ? m68k_areg(regs,r) : m68k_dreg(regs,r);
  261.     if (!(dp & 0x800)) dispreg = (uae_s32)(uae_s16)(dispreg);
  262.     dispreg <<= (dp >> 9) & 3;
  263.  
  264.     if (dp & 0x100) {
  265.         uae_s32 outer = 0,disp = 0;
  266.         uae_s32 base = addr;
  267.         char name[10];
  268.         sprintf(name,"PC, ");
  269.         if (dp & 0x80) { base = 0; name[0] = 0; }
  270.         if (dp & 0x40) dispreg = 0;
  271.         if ((dp & 0x30) == 0x20) { disp = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  272.         if ((dp & 0x30) == 0x30) { disp = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  273.         base += disp;
  274.  
  275.         if ((dp & 0x3) == 0x2) { outer = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  276.         if ((dp & 0x3) == 0x3) { outer = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  277.  
  278.         if (!(dp & 4)) base += dispreg;
  279.         if (dp & 3) base = get_long (base);
  280.         if (dp & 4) base += dispreg;
  281.  
  282.         addr = base + outer;
  283.         sprintf(buffer,"(%s%c%d.%c*%d+%ld)+%ld == $%08lx", name,
  284.             dp & 0x8000 ? 'A' : 'D', (int)r, dp & 0x800 ? 'L' : 'W',
  285.             1 << ((dp >> 9) & 3),
  286.             disp,outer,
  287.             (long unsigned int)addr);
  288.     } else {
  289.       addr += (uae_s32)((uae_s8)disp8) + dispreg;
  290.       sprintf(buffer,"(PC, %c%d.%c*%d, $%02x) == $%08lx", dp & 0x8000 ? 'A' : 'D',
  291.         (int)r, dp & 0x800 ? 'L' : 'W',  1 << ((dp >> 9) & 3),
  292.         disp8, (long unsigned int)addr);
  293.     }
  294.     break;
  295.      case absw:
  296.     sprintf(buffer,"$%08lx", (long unsigned int)(uae_s32)(uae_s16)get_iword_1(m68kpc_offset));
  297.     m68kpc_offset += 2;
  298.     break;
  299.      case absl:
  300.     sprintf(buffer,"$%08lx", (long unsigned int)get_ilong_1(m68kpc_offset));
  301.     m68kpc_offset += 4;
  302.     break;
  303.      case imm:
  304.     switch(size){
  305.      case sz_byte:
  306.         sprintf(buffer,"#$%02x", (unsigned int)(get_iword_1(m68kpc_offset) & 0xff));
  307.         m68kpc_offset += 2;
  308.         break;
  309.      case sz_word:
  310.         sprintf(buffer,"#$%04x", (unsigned int)(get_iword_1(m68kpc_offset) & 0xffff));
  311.         m68kpc_offset += 2;
  312.         break;
  313.      case sz_long:
  314.         sprintf(buffer,"#$%08lx", (long unsigned int)(get_ilong_1(m68kpc_offset)));
  315.         m68kpc_offset += 4;
  316.         break;
  317.      default:
  318.         break;
  319.     }
  320.     break;
  321.      case imm0:
  322.     offset = (uae_s32)(uae_s8)get_iword_1(m68kpc_offset);
  323.     m68kpc_offset += 2;
  324.     sprintf(buffer,"#$%02x", (unsigned int)(offset & 0xff));
  325.     break;
  326.      case imm1:
  327.     offset = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset);
  328.     m68kpc_offset += 2;
  329.     sprintf(buffer,"#$%04x", (unsigned int)(offset & 0xffff));
  330.     break;
  331.      case imm2:
  332.     offset = (uae_s32)get_ilong_1(m68kpc_offset);
  333.     m68kpc_offset += 4;
  334.     sprintf(buffer,"#$%08lx", (long unsigned int)offset);
  335.     break;
  336.      case immi:
  337.     offset = (uae_s32)(uae_s8)(reg & 0xff);
  338.     sprintf(buffer,"#$%08lx", (long unsigned int)offset);
  339.     break;
  340.      default:
  341.     break;
  342.     }
  343.     if (buf == 0)
  344.     printf("%s", buffer);
  345.     else
  346.     strcat(buf, buffer);
  347.     return offset;
  348. }
  349.  
  350. /* The plan is that this will take over the job of exception 3 handling -
  351.  * the CPU emulation functions will just do a longjmp to m68k_go whenever
  352.  * they hit an odd address. */
  353. static int verify_ea(int reg, amodes mode, wordsizes size, uae_u32 *val)
  354. {
  355.     uae_u16 dp;
  356.     uae_s8 disp8;
  357.     uae_s16 disp16;
  358.     int r;
  359.     uae_u32 dispreg;
  360.     uaecptr addr;
  361.     uae_s32 offset = 0;
  362.  
  363.     switch(mode){
  364.      case Dreg:
  365.     *val = m68k_dreg (regs, reg);
  366.     return 1;
  367.      case Areg:
  368.     *val = m68k_areg (regs, reg);
  369.     return 1;
  370.  
  371.      case Aind:
  372.      case Aipi:
  373.     addr = m68k_areg (regs, reg);
  374.     break;
  375.      case Apdi:
  376.     addr = m68k_areg (regs, reg);
  377.     break;
  378.      case Ad16:
  379.     disp16 = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  380.     addr = m68k_areg(regs,reg) + (uae_s16)disp16;
  381.     break;
  382.      case Ad8r:
  383.     addr = m68k_areg (regs, reg);
  384.      d8r_common:
  385.     dp = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  386.     disp8 = dp & 0xFF;
  387.     r = (dp & 0x7000) >> 12;
  388.     dispreg = dp & 0x8000 ? m68k_areg(regs,r) : m68k_dreg(regs,r);
  389.     if (!(dp & 0x800)) dispreg = (uae_s32)(uae_s16)(dispreg);
  390.     dispreg <<= (dp >> 9) & 3;
  391.  
  392.     if (dp & 0x100) {
  393.         uae_s32 outer = 0, disp = 0;
  394.         uae_s32 base = addr;
  395.         if (dp & 0x80) base = 0;
  396.         if (dp & 0x40) dispreg = 0;
  397.         if ((dp & 0x30) == 0x20) { disp = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  398.         if ((dp & 0x30) == 0x30) { disp = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  399.         base += disp;
  400.  
  401.         if ((dp & 0x3) == 0x2) { outer = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset); m68kpc_offset += 2; }
  402.         if ((dp & 0x3) == 0x3) { outer = get_ilong_1(m68kpc_offset); m68kpc_offset += 4; }
  403.  
  404.         if (!(dp & 4)) base += dispreg;
  405.         if (dp & 3) base = get_long (base);
  406.         if (dp & 4) base += dispreg;
  407.  
  408.         addr = base + outer;
  409.     } else {
  410.       addr += (uae_s32)((uae_s8)disp8) + dispreg;
  411.     }
  412.     break;
  413.      case PC16:
  414.     addr = m68k_getpc() + m68kpc_offset;
  415.     disp16 = get_iword_1(m68kpc_offset); m68kpc_offset += 2;
  416.     addr += (uae_s16)disp16;
  417.     break;
  418.      case PC8r:
  419.     addr = m68k_getpc() + m68kpc_offset;
  420.     goto d8r_common;
  421.      case absw:
  422.     addr = (uae_s32)(uae_s16)get_iword_1(m68kpc_offset);
  423.     m68kpc_offset += 2;
  424.     break;
  425.      case absl:
  426.     addr = get_ilong_1(m68kpc_offset);
  427.     m68kpc_offset += 4;
  428.     break;
  429.      case imm:
  430.     switch(size){
  431.      case sz_byte:
  432.         *val = get_iword_1(m68kpc_offset) & 0xff;
  433.         m68kpc_offset += 2;
  434.         break;
  435.      case sz_word:
  436.         *val = get_iword_1(m68kpc_offset) & 0xffff;
  437.         m68kpc_offset += 2;
  438.         break;
  439.      case sz_long:
  440.         *val = get_ilong_1(m68kpc_offset);
  441.         m68kpc_offset += 4;
  442.         break;
  443.      default:
  444.         break;
  445.     }
  446.     return 1;
  447.      case imm0:
  448.     *val = (uae_s32)(uae_s8)get_iword_1 (m68kpc_offset);
  449.     m68kpc_offset += 2;
  450.     return 1;
  451.      case imm1:
  452.     *val = (uae_s32)(uae_s16)get_iword_1 (m68kpc_offset);
  453.     m68kpc_offset += 2;
  454.     return 1;
  455.      case imm2:
  456.     *val = get_ilong_1 (m68kpc_offset);
  457.     m68kpc_offset += 4;
  458.     return 1;
  459.      case immi:
  460.     *val = (uae_s32)(uae_s8)(reg & 0xff);
  461.     return 1;
  462.      default:
  463.     addr = 0;
  464.     break;
  465.     }
  466.     if ((addr & 1) == 0)
  467.     return 1;
  468.  
  469.     last_addr_for_exception_3 = m68k_getpc() + m68kpc_offset;
  470.     last_fault_for_exception_3 = addr;
  471.     return 0;
  472. }
  473.  
  474. void MakeSR(void)
  475. {
  476. #if 0
  477.     assert((regs.t1 & 1) == regs.t1);
  478.     assert((regs.t0 & 1) == regs.t0);
  479.     assert((regs.s & 1) == regs.s);
  480.     assert((regs.m & 1) == regs.m);
  481.     assert((XFLG & 1) == XFLG);
  482.     assert((NFLG & 1) == NFLG);
  483.     assert((ZFLG & 1) == ZFLG);
  484.     assert((VFLG & 1) == VFLG);
  485.     assert((CFLG & 1) == CFLG);
  486. #endif
  487.     regs.sr = ((regs.t1 << 15) | (regs.t0 << 14)
  488.            | (regs.s << 13) | (regs.m << 12) | (regs.intmask << 8)
  489.            | (XFLG << 4) | (NFLG << 3) | (ZFLG << 2) | (VFLG << 1)
  490.            |  CFLG);
  491. }
  492.  
  493. void MakeFromSR(void)
  494. {
  495.     int oldm = regs.m;
  496.     int olds = regs.s;
  497.  
  498.     regs.t1 = (regs.sr >> 15) & 1;
  499.     regs.t0 = (regs.sr >> 14) & 1;
  500.     regs.s = (regs.sr >> 13) & 1;
  501.     regs.m = (regs.sr >> 12) & 1;
  502.     regs.intmask = (regs.sr >> 8) & 7;
  503.     XFLG = (regs.sr >> 4) & 1;
  504.     NFLG = (regs.sr >> 3) & 1;
  505.     ZFLG = (regs.sr >> 2) & 1;
  506.     VFLG = (regs.sr >> 1) & 1;
  507.     CFLG = regs.sr & 1;
  508.     if (CPU_LEVEL >= 2) {
  509.     if (olds != regs.s) {
  510.         if (olds) {
  511.         if (oldm)
  512.             regs.msp = m68k_areg(regs, 7);
  513.         else
  514.             regs.isp = m68k_areg(regs, 7);
  515.         m68k_areg(regs, 7) = regs.usp;
  516.         } else {
  517.         regs.usp = m68k_areg(regs, 7);
  518.         m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
  519.         }
  520.     } else if (olds && oldm != regs.m) {
  521.         if (oldm) {
  522.         regs.msp = m68k_areg(regs, 7);
  523.         m68k_areg(regs, 7) = regs.isp;
  524.         } else {
  525.         regs.isp = m68k_areg(regs, 7);
  526.         m68k_areg(regs, 7) = regs.msp;
  527.         }
  528.     }
  529.     } else {
  530.     if (olds != regs.s) {
  531.         if (olds) {
  532.         regs.isp = m68k_areg(regs, 7);
  533.         m68k_areg(regs, 7) = regs.usp;
  534.         } else {
  535.         regs.usp = m68k_areg(regs, 7);
  536.         m68k_areg(regs, 7) = regs.isp;
  537.         }
  538.     }
  539.     }
  540.  
  541.     regs.spcflags |= SPCFLAG_INT;
  542.     if (regs.t1 || regs.t0)
  543.     regs.spcflags |= SPCFLAG_TRACE;
  544.     else
  545.     regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
  546. }
  547.  
  548. void Exception(int nr, uaecptr oldpc)
  549. {
  550.     compiler_flush_jsr_stack();
  551.     MakeSR();
  552.     if (!regs.s) {
  553.     regs.usp = m68k_areg(regs, 7);
  554.     if (CPU_LEVEL >= 2)
  555.         m68k_areg(regs, 7) = regs.m ? regs.msp : regs.isp;
  556.     else
  557.         m68k_areg(regs, 7) = regs.isp;
  558.     regs.s = 1;
  559.     }
  560.     if (CPU_LEVEL > 0) {
  561.     if (nr == 2 || nr == 3) {
  562.         int i;
  563.         /* @@@ this is probably wrong (?) */
  564.         for (i = 0 ; i < 12 ; i++) {
  565.         m68k_areg(regs, 7) -= 2;
  566.         put_word (m68k_areg(regs, 7), 0);
  567.         }
  568.         m68k_areg(regs, 7) -= 2;
  569.         put_word (m68k_areg(regs, 7), 0xa000 + nr * 4);
  570.     } else if (nr ==5 || nr == 6 || nr == 7 || nr == 9) {
  571.         m68k_areg(regs, 7) -= 4;
  572.         put_long (m68k_areg(regs, 7), oldpc);
  573.         m68k_areg(regs, 7) -= 2;
  574.         put_word (m68k_areg(regs, 7), 0x2000 + nr * 4);
  575.     } else if (regs.m && nr >= 24 && nr < 32) {
  576.         m68k_areg(regs, 7) -= 2;
  577.         put_word (m68k_areg(regs, 7), nr * 4);
  578.         m68k_areg(regs, 7) -= 4;
  579.         put_long (m68k_areg(regs, 7), m68k_getpc ());
  580.         m68k_areg(regs, 7) -= 2;
  581.         put_word (m68k_areg(regs, 7), regs.sr);
  582.         regs.sr |= (1 << 13);
  583.         regs.msp = m68k_areg(regs, 7);
  584.         m68k_areg(regs, 7) = regs.isp;
  585.         m68k_areg(regs, 7) -= 2;
  586.         put_word (m68k_areg(regs, 7), 0x1000 + nr * 4);
  587.     } else {
  588.         m68k_areg(regs, 7) -= 2;
  589.         put_word (m68k_areg(regs, 7), nr * 4);
  590.     }
  591.     } else {
  592.     if (nr == 2 || nr == 3) {
  593.         m68k_areg(regs, 7) -= 12;
  594.         /* ??????? */
  595.         if (nr == 3) {
  596.         put_long (m68k_areg(regs, 7), last_fault_for_exception_3);
  597.         put_word (m68k_areg(regs, 7)+4, last_op_for_exception_3);
  598.         put_long (m68k_areg(regs, 7)+8, last_addr_for_exception_3);
  599.         }
  600.         write_log ("Exception!\n");
  601.         goto kludge_me_do;
  602.     }
  603.     }
  604.     m68k_areg(regs, 7) -= 4;
  605.     put_long (m68k_areg(regs, 7), m68k_getpc ());
  606. kludge_me_do:
  607.     m68k_areg(regs, 7) -= 2;
  608.     put_word (m68k_areg(regs, 7), regs.sr);
  609.     m68k_setpc(get_long(regs.vbr + 4*nr));
  610.     regs.t1 = regs.t0 = regs.m = 0;
  611.     regs.spcflags &= ~(SPCFLAG_TRACE | SPCFLAG_DOTRACE);
  612. }
  613.  
  614. static void Interrupt(int nr)
  615. {
  616.     assert(nr < 8 && nr >= 0);
  617.     lastint_regs = regs;
  618.     lastint_no = nr;
  619.     Exception(nr+24, 0);
  620.  
  621.     regs.intmask = nr;
  622.     regs.spcflags |= SPCFLAG_INT;
  623. }
  624.  
  625. static int caar, cacr;
  626.  
  627. void m68k_move2c (int regno, uae_u32 *regp)
  628. {
  629.     if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
  630.     op_illg (0x4E7B);
  631.     else
  632.     switch (regno) {
  633.      case 0: regs.sfc = *regp & 7; break;
  634.      case 1: regs.dfc = *regp & 7; break;
  635.      case 2: cacr = *regp & 0x3; break;    /* ignore C and CE */
  636.      case 0x800: regs.usp = *regp; break;
  637.      case 0x801: regs.vbr = *regp; break;
  638.      case 0x802: caar = *regp &0xfc; break;
  639.      case 0x803: regs.msp = *regp; if (regs.m == 1) m68k_areg(regs, 7) = regs.msp; break;
  640.      case 0x804: regs.isp = *regp; if (regs.m == 0) m68k_areg(regs, 7) = regs.isp; break;
  641.      default:
  642.         op_illg (0x4E7B);
  643.         break;
  644.     }
  645. }
  646.  
  647. void m68k_movec2 (int regno, uae_u32 *regp)
  648. {
  649.     if (CPU_LEVEL == 1 && (regno & 0x7FF) > 1)
  650.     op_illg (0x4E7A);
  651.     else
  652.     switch (regno) {
  653.      case 0: *regp = regs.sfc; break;
  654.      case 1: *regp = regs.dfc; break;
  655.      case 2: *regp = cacr; break;
  656.      case 0x800: *regp = regs.usp; break;
  657.      case 0x801: *regp = regs.vbr; break;
  658.      case 0x802: *regp = caar; break;
  659.      case 0x803: *regp = regs.m == 1 ? m68k_areg(regs, 7) : regs.msp; break;
  660.      case 0x804: *regp = regs.m == 0 ? m68k_areg(regs, 7) : regs.isp; break;
  661.      default:
  662.         op_illg (0x4E7A);
  663.         break;
  664.     }
  665. }
  666.  
  667. static __inline__ int
  668. div_unsigned(uae_u32 src_hi, uae_u32 src_lo, uae_u32 div, uae_u32 *quot, uae_u32 *rem)
  669. {
  670.     uae_u32 q = 0, cbit = 0;
  671.     int i;
  672.  
  673.     if (div <= src_hi) {
  674.         return(1);
  675.     }
  676.     for (i = 0 ; i < 32 ; i++) {
  677.         cbit = src_hi & 0x80000000ul;
  678.         src_hi <<= 1;
  679.         if (src_lo & 0x80000000ul) src_hi++;
  680.         src_lo <<= 1;
  681.         q = q << 1;
  682.         if (cbit || div <= src_hi) {
  683.             q |= 1;
  684.             src_hi -= div;
  685.         }
  686.     }
  687.     *quot = q;
  688.     *rem = src_hi;
  689.     return(0);
  690. }
  691.  
  692. void m68k_divl (uae_u32 opcode, uae_u32 src, uae_u16 extra, uaecptr oldpc)
  693. {
  694. #if defined(uae_s64)
  695.     if (src == 0) {
  696.     Exception(5,oldpc);
  697.     return;
  698.     }
  699.     if (extra & 0x800) {
  700.     /* signed variant */
  701.     uae_s64 a = (uae_s64)(uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  702.     uae_s64 quot, rem;
  703.  
  704.     if (extra & 0x400) {
  705.         a &= 0xffffffffu;
  706.         a |= (uae_s64)m68k_dreg(regs, extra & 7) << 32;
  707.     }
  708.     rem = a % (uae_s64)(uae_s32)src;
  709.     quot = a / (uae_s64)(uae_s32)src;
  710.     if ((quot & UVAL64(0xffffffff80000000)) != 0
  711.         && (quot & UVAL64(0xffffffff80000000)) != UVAL64(0xffffffff80000000))
  712.     {
  713.         VFLG = NFLG = 1;
  714.         CFLG = 0;
  715.     }
  716.     else {
  717.         if (((uae_s32)rem < 0) != ((uae_s64)a < 0)) rem = -rem;
  718.         VFLG = CFLG = 0;
  719.         ZFLG = ((uae_s32)quot) == 0;
  720.         NFLG = ((uae_s32)quot) < 0;
  721.         m68k_dreg(regs, extra & 7) = rem;
  722.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  723.     }
  724.     } else {
  725.     /* unsigned */
  726.     uae_u64 a = (uae_u64)(uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  727.     uae_u64 quot, rem;
  728.  
  729.     if (extra & 0x400) {
  730.         a &= 0xffffffffu;
  731.         a |= (uae_u64)m68k_dreg(regs, extra & 7) << 32;
  732.     }
  733.     rem = a % (uae_u64)src;
  734.     quot = a / (uae_u64)src;
  735.     if (quot > 0xffffffffu) {
  736.         VFLG = NFLG = 1;
  737.         CFLG = 0;
  738.     }
  739.     else {
  740.         VFLG = CFLG = 0;
  741.         ZFLG = ((uae_s32)quot) == 0;
  742.         NFLG = ((uae_s32)quot) < 0;
  743.         m68k_dreg(regs, extra & 7) = rem;
  744.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  745.     }
  746.     }
  747. #else
  748.     if (src == 0) {
  749.     Exception(5,oldpc);
  750.     return;
  751.     }
  752.     if (extra & 0x800) {
  753.     /* signed variant */
  754.     uae_s32 lo = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  755.     uae_s32 hi = lo < 0 ? -1 : 0;
  756.     uae_s32 save_high;
  757.     uae_u32 quot, rem;
  758.     uae_u32 sign;
  759.  
  760.     if (extra & 0x400) {
  761.         hi = (uae_s32)m68k_dreg(regs, extra & 7);
  762.     }
  763.     save_high = hi;
  764.     sign = (hi ^ src);
  765.     if (hi < 0) {
  766.         hi = ~hi;
  767.         lo = -lo;
  768.         if (lo == 0) hi++;
  769.     }
  770.     if ((uae_s32)src < 0) src = -src;
  771.     if (div_unsigned(hi, lo, src, ", &rem) ||
  772.         (sign & 0x80000000) ? quot > 0x80000000 : quot > 0x7fffffff) {
  773.         VFLG = NFLG = 1;
  774.         CFLG = 0;
  775.     }
  776.     else {
  777.         if (sign & 0x80000000) quot = -quot;
  778.         if (((uae_s32)rem < 0) != (save_high < 0)) rem = -rem;
  779.         VFLG = CFLG = 0;
  780.         ZFLG = ((uae_s32)quot) == 0;
  781.         NFLG = ((uae_s32)quot) < 0;
  782.         m68k_dreg(regs, extra & 7) = rem;
  783.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  784.     }
  785.     } else {
  786.     /* unsigned */
  787.     uae_u32 lo = (uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  788.     uae_u32 hi = 0;
  789.     uae_u32 quot, rem;
  790.  
  791.     if (extra & 0x400) {
  792.         hi = (uae_u32)m68k_dreg(regs, extra & 7);
  793.     }
  794.     if (div_unsigned(hi, lo, src, ", &rem)) {
  795.         VFLG = NFLG = 1;
  796.         CFLG = 0;
  797.     }
  798.     else {
  799.         VFLG = CFLG = 0;
  800.         ZFLG = ((uae_s32)quot) == 0;
  801.         NFLG = ((uae_s32)quot) < 0;
  802.         m68k_dreg(regs, extra & 7) = rem;
  803.         m68k_dreg(regs, (extra >> 12) & 7) = quot;
  804.     }
  805.     }
  806. #endif
  807. }
  808.  
  809. static __inline__ void
  810. mul_unsigned(uae_u32 src1, uae_u32 src2, uae_u32 *dst_hi, uae_u32 *dst_lo)
  811. {
  812.     uae_u32 r0 = (src1 & 0xffff) * (src2 & 0xffff);
  813.     uae_u32 r1 = ((src1 >> 16) & 0xffff) * (src2 & 0xffff);
  814.     uae_u32 r2 = (src1 & 0xffff) * ((src2 >> 16) & 0xffff);
  815.     uae_u32 r3 = ((src1 >> 16) & 0xffff) * ((src2 >> 16) & 0xffff);
  816.     uae_u32 lo;
  817.  
  818.     lo = r0 + ((r1 << 16) & 0xffff0000ul);
  819.     if (lo < r0) r3++;
  820.     r0 = lo;
  821.     lo = r0 + ((r2 << 16) & 0xffff0000ul);
  822.     if (lo < r0) r3++;
  823.     r3 += ((r1 >> 16) & 0xffff) + ((r2 >> 16) & 0xffff);
  824.     *dst_lo = lo;
  825.     *dst_hi = r3;
  826. }
  827.  
  828. void m68k_mull (uae_u32 opcode, uae_u32 src, uae_u16 extra)
  829. {
  830. #if defined(uae_s64)
  831.     if (extra & 0x800) {
  832.     /* signed variant */
  833.     uae_s64 a = (uae_s64)(uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  834.  
  835.     a *= (uae_s64)(uae_s32)src;
  836.     VFLG = CFLG = 0;
  837.     ZFLG = a == 0;
  838.     NFLG = a < 0;
  839.     if (extra & 0x400)
  840.         m68k_dreg(regs, extra & 7) = a >> 32;
  841.     else if ((a & UVAL64(0xffffffff80000000)) != 0
  842.          && (a & UVAL64(0xffffffff80000000)) != UVAL64(0xffffffff80000000))
  843.     {
  844.         VFLG = 1;
  845.     }
  846.     m68k_dreg(regs, (extra >> 12) & 7) = (uae_u32)a;
  847.     } else {
  848.     /* unsigned */
  849.     uae_u64 a = (uae_u64)(uae_u32)m68k_dreg(regs, (extra >> 12) & 7);
  850.  
  851.     a *= (uae_u64)src;
  852.     VFLG = CFLG = 0;
  853.     ZFLG = a == 0;
  854.     NFLG = ((uae_s64)a) < 0;
  855.     if (extra & 0x400)
  856.         m68k_dreg(regs, extra & 7) = a >> 32;
  857.     else if ((a & UVAL64(0xffffffff00000000)) != 0) {
  858.         VFLG = 1;
  859.     }
  860.     m68k_dreg(regs, (extra >> 12) & 7) = (uae_u32)a;
  861.     }
  862. #else
  863.     if (extra & 0x800) {
  864.     /* signed variant */
  865.     uae_s32 src1,src2;
  866.     uae_u32 dst_lo,dst_hi;
  867.     uae_u32 sign;
  868.  
  869.     src1 = (uae_s32)src;
  870.     src2 = (uae_s32)m68k_dreg(regs, (extra >> 12) & 7);
  871.     sign = (src1 ^ src2);
  872.     if (src1 < 0) src1 = -src1;
  873.     if (src2 < 0) src2 = -src2;
  874.     mul_unsigned((uae_u32)src1,(uae_u32)src2,&dst_hi,&dst_lo);
  875.     if (sign & 0x80000000) {
  876.         dst_hi = ~dst_hi;
  877.         dst_lo = -dst_lo;
  878.         if (dst_lo == 0) dst_hi++;
  879.     }
  880.     VFLG = CFLG = 0;
  881.     ZFLG = dst_hi == 0 && dst_lo == 0;
  882.     NFLG = ((uae_s32)dst_hi) < 0;
  883.     if (extra & 0x400)
  884.         m68k_dreg(regs, extra & 7) = dst_hi;
  885.     else if ((dst_hi != 0 || (dst_lo & 0x80000000) != 0)
  886.          && ((dst_hi & 0xffffffff) != 0xffffffff
  887.              || (dst_lo & 0x80000000) != 0x80000000))
  888.     {
  889.         VFLG = 1;
  890.     }
  891.     m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
  892.     } else {
  893.     /* unsigned */
  894.     uae_u32 dst_lo,dst_hi;
  895.  
  896.     mul_unsigned(src,(uae_u32)m68k_dreg(regs, (extra >> 12) & 7),&dst_hi,&dst_lo);
  897.  
  898.     VFLG = CFLG = 0;
  899.     ZFLG = dst_hi == 0 && dst_lo == 0;
  900.     NFLG = ((uae_s32)dst_hi) < 0;
  901.     if (extra & 0x400)
  902.         m68k_dreg(regs, extra & 7) = dst_hi;
  903.     else if (dst_hi != 0) {
  904.         VFLG = 1;
  905.     }
  906.     m68k_dreg(regs, (extra >> 12) & 7) = dst_lo;
  907.     }
  908. #endif
  909. }
  910. static char* ccnames[] =
  911. { "T ","F ","HI","LS","CC","CS","NE","EQ",
  912.   "VC","VS","PL","MI","GE","LT","GT","LE" };
  913.  
  914. void m68k_reset(void)
  915. {
  916.     m68k_areg(regs, 7) = get_long(0x00f80000);
  917.     m68k_setpc(get_long(0x00f80004));
  918.     regs.kick_mask = 0xF80000;
  919.     regs.s = 1;
  920.     regs.m = 0;
  921.     regs.stopped = 0;
  922.     regs.t1 = 0;
  923.     regs.t0 = 0;
  924.     ZFLG = CFLG = NFLG = VFLG = 0;
  925.     regs.spcflags = 0;
  926.     regs.intmask = 7;
  927.     regs.vbr = regs.sfc = regs.dfc = 0;
  928.     regs.fpcr = regs.fpsr = regs.fpiar = 0;
  929.     customreset();
  930. }
  931.  
  932. void REGPARAM2 op_illg(uae_u32 opcode)
  933. {
  934.     uaecptr pc = m68k_getpc();
  935.  
  936.     if (cloanto_rom && (opcode & 0xF100) == 0x7100) {
  937.     m68k_dreg (regs, (opcode >> 9) & 7) = (uae_s8)(opcode & 0xFF);
  938.     m68k_incpc (2);
  939.     fill_prefetch_0 ();
  940.     return;
  941.     }
  942.  
  943.     compiler_flush_jsr_stack();
  944.     if (opcode == 0x4E7B && get_long(0x10) == 0 && (pc & 0xF80000) == 0xF80000) {
  945.     write_log("Your Kickstart requires a 68020 CPU. Giving up.\n");
  946.     broken_in = 1;
  947.     regs.spcflags |= SPCFLAG_BRK;
  948.     quit_program = 1;
  949.     }
  950.     if (opcode == 0xFF0D) {
  951.     if ((pc & 0xF80000) == 0xF80000) {
  952.         /* This is from the dummy Kickstart replacement */
  953.         uae_u16 arg = get_iword (2);
  954.         m68k_incpc(4);
  955.         ersatz_perform (arg);
  956.         fill_prefetch_0 ();
  957.         return;
  958.     } else if ((pc & 0xF80000) == 0xF00000) {
  959.         /* User-mode STOP replacement */
  960.         m68k_setstopped(1);
  961.         return;
  962.     }
  963.     }
  964.  
  965.     if ((opcode & 0xF000) == 0xA000 && (pc & 0xF80000) == 0xF00000) {
  966.     /* Calltrap. */
  967.     m68k_incpc(2);
  968.     call_calltrap (opcode & 0xFFF);
  969.     fill_prefetch_0 ();
  970.     return;
  971.     }
  972.  
  973.     if ((opcode & 0xF000) == 0xF000) {
  974.     Exception(0xB,0);
  975.     return;
  976.     }
  977.     if ((opcode & 0xF000) == 0xA000) {
  978.     if ((pc & 0xF80000) == 0xF00000) {
  979.         /* Calltrap. */
  980.         call_calltrap (opcode & 0xFFF);
  981.     }
  982.     Exception(0xA,0);
  983.     return;
  984.     }
  985.     sprintf (warning_buffer, "Illegal instruction: %04x at %08lx\n", opcode, pc);
  986.     write_log (warning_buffer);
  987.     Exception(4,0);
  988. }
  989.  
  990. void mmu_op(uae_u32 opcode, uae_u16 extra)
  991. {
  992.     if ((extra & 0xB000) == 0) { /* PMOVE instruction */
  993.  
  994.     } else if ((extra & 0xF000) == 0x2000) { /* PLOAD instruction */
  995.     } else if ((extra & 0xF000) == 0x8000) { /* PTEST instruction */
  996.     } else
  997.     op_illg(opcode);
  998. }
  999.  
  1000. static int n_insns=0, n_spcinsns=0;
  1001.  
  1002. static uaecptr last_trace_ad = 0;
  1003.  
  1004. static __inline__ void do_trace(void)
  1005. {
  1006.     if (regs.spcflags & SPCFLAG_TRACE) {        /* 6 */
  1007.     if (regs.t0) {
  1008.         uae_u16 opcode;
  1009.         /* should also include TRAP, CHK, SR modification FPcc */
  1010.         /* probably never used so why bother */
  1011.         /* We can afford this to be inefficient... */
  1012.         m68k_setpc(m68k_getpc());
  1013.         opcode = get_word(regs.pc);
  1014.         if (opcode == 0x4e72         /* RTE */
  1015.         || opcode == 0x4e74         /* RTD */
  1016.         || opcode == 0x4e75         /* RTS */
  1017.         || opcode == 0x4e77         /* RTR */
  1018.         || opcode == 0x4e76         /* TRAPV */
  1019.         || (opcode & 0xffc0) == 0x4e80     /* JSR */
  1020.         || (opcode & 0xffc0) == 0x4ec0     /* JMP */
  1021.         || (opcode & 0xff00) == 0x6100  /* BSR */
  1022.         || ((opcode & 0xf000) == 0x6000    /* Bcc */
  1023.             && cctrue((opcode >> 8) & 0xf))
  1024.         || ((opcode & 0xf0f0) == 0x5050 /* DBcc */
  1025.             && !cctrue((opcode >> 8) & 0xf)
  1026.             && (uae_s16)m68k_dreg(regs, opcode & 7) != 0))
  1027.         {
  1028.         last_trace_ad = m68k_getpc();
  1029.         regs.spcflags &= ~SPCFLAG_TRACE;
  1030.         regs.spcflags |= SPCFLAG_DOTRACE;
  1031.         }
  1032.     } else if (regs.t1) {
  1033.         last_trace_ad = m68k_getpc();
  1034.         regs.spcflags &= ~SPCFLAG_TRACE;
  1035.         regs.spcflags |= SPCFLAG_DOTRACE;
  1036.     }
  1037.     }
  1038. }
  1039.  
  1040. static int do_specialties (void)
  1041. {
  1042.     /*n_spcinsns++;*/
  1043.     while (regs.spcflags & SPCFLAG_BLTNASTY) {
  1044.     do_cycles();
  1045.     if (regs.spcflags & SPCFLAG_DISK)
  1046.         do_disk();
  1047.     }
  1048.     run_compiled_code();
  1049.     if (regs.spcflags & SPCFLAG_DOTRACE) {
  1050.     Exception(9,last_trace_ad);
  1051.     }
  1052.     while (regs.spcflags & SPCFLAG_STOP) {
  1053.     do_cycles();
  1054.     if (regs.spcflags & SPCFLAG_DISK)
  1055.         do_disk();
  1056.     if (regs.spcflags & (SPCFLAG_INT | SPCFLAG_DOINT)){
  1057.         int intr = intlev();
  1058.         regs.spcflags &= ~(SPCFLAG_INT | SPCFLAG_DOINT);
  1059.         if (intr != -1 && intr > regs.intmask) {
  1060.         Interrupt(intr);
  1061.         regs.stopped = 0;
  1062.         regs.spcflags &= ~SPCFLAG_STOP;
  1063.         }
  1064.     }
  1065.     }
  1066.     do_trace();
  1067. #ifdef WANT_SLOW_MULTIPLY
  1068.     /* Kludge for Hardwired demo. The guys who wrote it should be
  1069.      * mutilated. */
  1070.     if (regs.spcflags & SPCFLAG_EXTRA_CYCLES) {
  1071.     do_cycles (); do_cycles (); do_cycles (); do_cycles ();
  1072.     regs.spcflags &= ~SPCFLAG_EXTRA_CYCLES;
  1073.     }
  1074. #endif
  1075.     if (regs.spcflags & SPCFLAG_DISK)
  1076.     do_disk();
  1077.  
  1078.     if (regs.spcflags & SPCFLAG_DOINT) {
  1079.     int intr = intlev();
  1080.     regs.spcflags &= ~SPCFLAG_DOINT;
  1081.     if (intr != -1 && intr > regs.intmask) {
  1082.         Interrupt(intr);
  1083.         regs.stopped = 0;
  1084.     }
  1085.     }
  1086.     if (regs.spcflags & SPCFLAG_INT) {
  1087.     regs.spcflags &= ~SPCFLAG_INT;
  1088.     regs.spcflags |= SPCFLAG_DOINT;
  1089.     }
  1090.     if (regs.spcflags & (SPCFLAG_BRK|SPCFLAG_MODE_CHANGE)) {
  1091.     regs.spcflags &= ~(SPCFLAG_BRK|SPCFLAG_MODE_CHANGE);
  1092.     return 1;
  1093.     }
  1094.     return 0;
  1095. }
  1096.  
  1097. static void m68k_run_1(void)
  1098. {
  1099.     for(;;) {
  1100.     uae_u32 opcode = get_iword(0);
  1101.  
  1102.     /* assert (!regs.stopped && !(regs.spcflags & SPCFLAG_STOP)); */
  1103. /*    regs_backup[backup_pointer = (backup_pointer + 1) % 16] = regs;*/
  1104. #if COUNT_INSTRS == 2
  1105.     if (table68k[opcode].handler != -1)
  1106.         instrcount[table68k[opcode].handler]++;
  1107. #elif COUNT_INSTRS == 1
  1108.     instrcount[opcode]++;
  1109. #endif
  1110. #if defined(X86_ASSEMBLY)
  1111.     __asm__ __volatile__("\tcall *%%ebx"
  1112.                  : : "b" (cpufunctbl[opcode]), "a" (opcode)
  1113.                  : "%eax", "%ebx", "%edx", "%ecx",
  1114.                  "%esi", "%edi", "%ebp", "memory", "cc");
  1115. #else
  1116.     (*cpufunctbl[opcode])(opcode);
  1117. #endif
  1118.     /*n_insns++;*/
  1119.     do_cycles();
  1120.     if (regs.spcflags) {
  1121.         if (do_specialties())
  1122.         return;
  1123.     }
  1124.     }
  1125. }
  1126.  
  1127. #ifdef X86_ASSEMBLY
  1128. static __inline__ void m68k_run1(void)
  1129. {
  1130.     /* Work around compiler bug: GCC doesn't push %ebp in m68k_run_1. */
  1131.     __asm__ __volatile__ ("pushl %%ebp\n\tcall *%0\n\tpopl %%ebp" : : "r" (m68k_run_1) : "%eax", "%edx", "%ecx", "memory", "cc");
  1132. }
  1133. #else
  1134. #define m68k_run1 m68k_run_1
  1135. #endif
  1136.  
  1137. int in_m68k_go = 0;
  1138.  
  1139. void m68k_go(int may_quit)
  1140. {
  1141.     if (in_m68k_go || !may_quit) {
  1142.     write_log("Bug! m68k_go is not reentrant.\n");
  1143.     abort();
  1144.     }
  1145. #ifdef FRAME_RATE_HACK
  1146.     vsyncmintime = read_processor_time () + vsynctime;
  1147. #endif
  1148.     in_m68k_go++;
  1149.     for(;;) {
  1150.     if (quit_program > 0) {
  1151.         if (quit_program == 1)
  1152.         break;
  1153.         quit_program = 0;
  1154.         m68k_reset();
  1155.     }
  1156.     if (debugging)
  1157.         debug();
  1158.     m68k_run1();
  1159.     }
  1160.     in_m68k_go--;
  1161. }
  1162.  
  1163. static void m68k_verify(uaecptr addr, uaecptr *nextpc)
  1164. {
  1165.     uae_u32 opcode, val;
  1166.     struct instr *dp;
  1167.  
  1168.     opcode = get_iword_1(0);
  1169.     last_op_for_exception_3 = opcode;
  1170.     m68kpc_offset = 2;
  1171.  
  1172.     if (cpufunctbl[opcode] == op_illg) {
  1173.     opcode = 0x4AFC;
  1174.     }
  1175.     dp = table68k + opcode;
  1176.  
  1177.     if (dp->suse) {
  1178.     if (!verify_ea (dp->sreg, dp->smode, dp->size, &val)) {
  1179.         Exception (3, 0);
  1180.         return;
  1181.     }
  1182.     }
  1183.     if (dp->duse) {
  1184.     if (!verify_ea (dp->dreg, dp->dmode, dp->size, &val)) {
  1185.         Exception (3, 0);
  1186.         return;
  1187.     }
  1188.     }
  1189. }
  1190.  
  1191. void m68k_disasm(uaecptr addr, uaecptr *nextpc, int cnt)
  1192. {
  1193.     uaecptr newpc = 0;
  1194.     m68kpc_offset = addr - m68k_getpc();
  1195.     for (;cnt--;){
  1196.     char instrname[20],*ccpt;
  1197.     int opwords;
  1198.     uae_u32 opcode;
  1199.     struct mnemolookup *lookup;
  1200.     struct instr *dp;
  1201.     printf("%08lx: ", m68k_getpc() + m68kpc_offset);
  1202.     for(opwords = 0; opwords < 5; opwords++){
  1203.         printf("%04x ", get_iword_1(m68kpc_offset + opwords*2));
  1204.     }
  1205.     opcode = get_iword_1(m68kpc_offset);
  1206.     m68kpc_offset += 2;
  1207.     if (cpufunctbl[opcode] == op_illg) {
  1208.         opcode = 0x4AFC;
  1209.     }
  1210.     dp = table68k + opcode;
  1211.     for (lookup = lookuptab;lookup->mnemo != dp->mnemo; lookup++)
  1212.         ;
  1213.  
  1214.     strcpy(instrname,lookup->name);
  1215.     ccpt = strstr(instrname,"cc");
  1216.     if (ccpt != 0) {
  1217.         strncpy(ccpt,ccnames[dp->cc],2);
  1218.     }
  1219.     printf("%s", instrname);
  1220.     switch(dp->size){
  1221.      case sz_byte: printf(".B "); break;
  1222.      case sz_word: printf(".W "); break;
  1223.      case sz_long: printf(".L "); break;
  1224.      default: printf("   ");break;
  1225.     }
  1226.  
  1227.     if (dp->suse) {
  1228.         newpc = m68k_getpc() + m68kpc_offset;
  1229.         newpc += ShowEA(dp->sreg, dp->smode, dp->size, 0);
  1230.     }
  1231.     if (dp->suse && dp->duse)
  1232.         printf(",");
  1233.     if (dp->duse) {
  1234.         newpc = m68k_getpc() + m68kpc_offset;
  1235.         newpc += ShowEA(dp->dreg, dp->dmode, dp->size, 0);
  1236.     }
  1237.     if (ccpt != 0) {
  1238.         if (cctrue(dp->cc))
  1239.         printf(" == %08lx (TRUE)",newpc);
  1240.         else
  1241.         printf(" == %08lx (FALSE)",newpc);
  1242.     } else if ((opcode & 0xff00) == 0x6100) /* BSR */
  1243.         printf(" == %08lx",newpc);
  1244.     printf("\n");
  1245.     }
  1246.     if (nextpc) *nextpc = m68k_getpc() + m68kpc_offset;
  1247. }
  1248.  
  1249. void m68k_dumpstate(uaecptr *nextpc)
  1250. {
  1251.     int i;
  1252.     for(i = 0; i < 8; i++){
  1253.     printf("D%d: %08lx ", i, m68k_dreg(regs, i));
  1254.     if ((i & 3) == 3) printf("\n");
  1255.     }
  1256.     for(i = 0; i < 8; i++){
  1257.     printf("A%d: %08lx ", i, m68k_areg(regs, i));
  1258.     if ((i & 3) == 3) printf("\n");
  1259.     }
  1260.     if (regs.s == 0) regs.usp = m68k_areg(regs, 7);
  1261.     if (regs.s && regs.m) regs.msp = m68k_areg(regs, 7);
  1262.     if (regs.s && regs.m == 0) regs.isp = m68k_areg(regs, 7);
  1263.     printf("USP=%08lx ISP=%08lx MSP=%08lx VBR=%08lx\n",
  1264.         regs.usp,regs.isp,regs.msp,regs.vbr);
  1265.     printf ("T=%d%d S=%d M=%d X=%d N=%d Z=%d V=%d C=%d IMASK=%d\n",
  1266.         regs.t1, regs.t0, regs.s, regs.m,
  1267.         XFLG, NFLG, ZFLG, VFLG, CFLG, regs.intmask);
  1268.     for(i = 0; i < 8; i++){
  1269.     printf("FP%d: %g ", i, regs.fp[i]);
  1270.     if ((i & 3) == 3) printf("\n");
  1271.     }
  1272.     printf("N=%d Z=%d I=%d NAN=%d\n",
  1273.         (regs.fpsr & 0x8000000) != 0,
  1274.         (regs.fpsr & 0x4000000) != 0,
  1275.         (regs.fpsr & 0x2000000) != 0,
  1276.         (regs.fpsr & 0x1000000) != 0);
  1277. #ifndef NO_PREFETCH_BUFFER
  1278.     printf("prefetch %08lx\n", (unsigned long)do_get_mem_long(®s.prefetch));
  1279. #endif
  1280.     m68k_disasm(m68k_getpc(), nextpc, 1);
  1281.     if (nextpc) printf("next PC: %08lx\n", *nextpc);
  1282. }
  1283.